home *** CD-ROM | disk | FTP | other *** search
/ LG Super CD / LG Super CD.iso / bitpim / bitpim-0.62-setup.exe / {app} / bitpim.exe / serial / serialwin32.pyo (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2003-11-06  |  9.6 KB  |  257 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.3)
  3.  
  4. import win32file
  5. import win32event
  6. import win32con
  7. from serialutil import *
  8. VERSION = '$Revision: 1.27 $'.split()[1]
  9. MS_CTS_ON = 16
  10. MS_DSR_ON = 32
  11. MS_RING_ON = 64
  12. MS_RLSD_ON = 128
  13.  
  14. def device(portnum):
  15.     if portnum < 9:
  16.         return 'COM%d' % (portnum + 1)
  17.     else:
  18.         return '\\\\.\\COM%d' % (portnum + 1)
  19.  
  20.  
  21. class Serial(SerialBase):
  22.     BAUDRATES = (50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800, 9600, 19200, 38400, 57600, 115200)
  23.     
  24.     def open(self):
  25.         if self._port is None:
  26.             raise SerialException('Port must be configured before it can be used.')
  27.         
  28.         self.hComPort = None
  29.         
  30.         try:
  31.             self.hComPort = win32file.CreateFile(self.portstr, win32con.GENERIC_READ | win32con.GENERIC_WRITE, 0, None, win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL | win32con.FILE_FLAG_OVERLAPPED, None)
  32.         except Exception:
  33.             msg = None
  34.             self.hComPort = None
  35.             raise SerialException('could not open port: %s' % msg)
  36.  
  37.         win32file.SetupComm(self.hComPort, 4096, 4096)
  38.         self._orgTimeouts = win32file.GetCommTimeouts(self.hComPort)
  39.         self._reconfigurePort()
  40.         win32file.PurgeComm(self.hComPort, win32file.PURGE_TXCLEAR | win32file.PURGE_TXABORT | win32file.PURGE_RXCLEAR | win32file.PURGE_RXABORT)
  41.         self._overlappedRead = win32file.OVERLAPPED()
  42.         self._overlappedRead.hEvent = win32event.CreateEvent(None, 1, 0, None)
  43.         self._overlappedWrite = win32file.OVERLAPPED()
  44.         self._overlappedWrite.hEvent = win32event.CreateEvent(None, 0, 0, None)
  45.         self._isOpen = True
  46.  
  47.     
  48.     def _reconfigurePort(self):
  49.         if not (self.hComPort):
  50.             raise SerialException('Can only operate on a valid port handle')
  51.         
  52.         if self._timeout is None:
  53.             timeouts = (0, 0, 0, 0, 0)
  54.         elif self._timeout == 0:
  55.             timeouts = (win32con.MAXDWORD, 0, 0, 0, 0)
  56.         else:
  57.             timeouts = (0, 0, int(self._timeout * 1000), 0, 0)
  58.         win32file.SetCommTimeouts(self.hComPort, timeouts)
  59.         win32file.SetCommMask(self.hComPort, win32file.EV_ERR)
  60.         comDCB = win32file.GetCommState(self.hComPort)
  61.         comDCB.BaudRate = self._baudrate
  62.         if self._bytesize == FIVEBITS:
  63.             comDCB.ByteSize = 5
  64.         elif self._bytesize == SIXBITS:
  65.             comDCB.ByteSize = 6
  66.         elif self._bytesize == SEVENBITS:
  67.             comDCB.ByteSize = 7
  68.         elif self._bytesize == EIGHTBITS:
  69.             comDCB.ByteSize = 8
  70.         else:
  71.             raise ValueError('Unsupported number of data bits: %r' % self._bytesize)
  72.         if self._parity == PARITY_NONE:
  73.             comDCB.Parity = win32file.NOPARITY
  74.             comDCB.fParity = 0
  75.         elif self._parity == PARITY_EVEN:
  76.             comDCB.Parity = win32file.EVENPARITY
  77.             comDCB.fParity = 1
  78.         elif self._parity == PARITY_ODD:
  79.             comDCB.Parity = win32file.ODDPARITY
  80.             comDCB.fParity = 1
  81.         else:
  82.             raise ValueError('Unsupported parity mode: %r' % self._parity)
  83.         if self._stopbits == STOPBITS_ONE:
  84.             comDCB.StopBits = win32file.ONESTOPBIT
  85.         elif self._stopbits == STOPBITS_TWO:
  86.             comDCB.StopBits = win32file.TWOSTOPBITS
  87.         else:
  88.             raise ValueError('Unsupported number of stop bits: %r' % self._stopbits)
  89.         comDCB.fBinary = 1
  90.         if self._rtscts:
  91.             comDCB.fRtsControl = win32file.RTS_CONTROL_HANDSHAKE
  92.             comDCB.fDtrControl = win32file.DTR_CONTROL_HANDSHAKE
  93.         else:
  94.             comDCB.fRtsControl = win32file.RTS_CONTROL_ENABLE
  95.             comDCB.fDtrControl = win32file.DTR_CONTROL_ENABLE
  96.         comDCB.fOutxCtsFlow = self._rtscts
  97.         comDCB.fOutxDsrFlow = self._rtscts
  98.         comDCB.fOutX = self._xonxoff
  99.         comDCB.fInX = self._xonxoff
  100.         comDCB.fNull = 0
  101.         comDCB.fErrorChar = 0
  102.         comDCB.fAbortOnError = 0
  103.         win32file.SetCommState(self.hComPort, comDCB)
  104.  
  105.     
  106.     def close(self):
  107.         if self._isOpen:
  108.             if self.hComPort:
  109.                 win32file.SetCommTimeouts(self.hComPort, self._orgTimeouts)
  110.                 win32file.CloseHandle(self.hComPort)
  111.                 self.hComPort = None
  112.             
  113.             self._isOpen = False
  114.         
  115.  
  116.     
  117.     def makeDeviceName(self, port):
  118.         return device(port)
  119.  
  120.     
  121.     def inWaiting(self):
  122.         (flags, comstat) = win32file.ClearCommError(self.hComPort)
  123.         return comstat.cbInQue
  124.  
  125.     
  126.     def read(self, size = 1):
  127.         if not (self.hComPort):
  128.             raise portNotOpenError
  129.         
  130.         if size > 0:
  131.             win32event.ResetEvent(self._overlappedRead.hEvent)
  132.             (flags, comstat) = win32file.ClearCommError(self.hComPort)
  133.             if self.timeout == 0:
  134.                 n = min(comstat.cbInQue, size)
  135.                 if n > 0:
  136.                     (rc, buf) = win32file.ReadFile(self.hComPort, win32file.AllocateReadBuffer(n), self._overlappedRead)
  137.                     win32event.WaitForSingleObject(self._overlappedRead.hEvent, win32event.INFINITE)
  138.                     read = str(buf)
  139.                 else:
  140.                     read = ''
  141.             else:
  142.                 (rc, buf) = win32file.ReadFile(self.hComPort, win32file.AllocateReadBuffer(size), self._overlappedRead)
  143.                 n = win32file.GetOverlappedResult(self.hComPort, self._overlappedRead, 1)
  144.                 read = str(buf[:n])
  145.         else:
  146.             read = ''
  147.         return read
  148.  
  149.     
  150.     def write(self, s):
  151.         if not (self.hComPort):
  152.             raise portNotOpenError
  153.         
  154.         if s:
  155.             (err, n) = win32file.WriteFile(self.hComPort, s, self._overlappedWrite)
  156.             if err:
  157.                 win32event.WaitForSingleObject(self._overlappedWrite.hEvent, win32event.INFINITE)
  158.             
  159.         
  160.  
  161.     
  162.     def flushInput(self):
  163.         if not (self.hComPort):
  164.             raise portNotOpenError
  165.         
  166.         win32file.PurgeComm(self.hComPort, win32file.PURGE_RXCLEAR | win32file.PURGE_RXABORT)
  167.  
  168.     
  169.     def flushOutput(self):
  170.         if not (self.hComPort):
  171.             raise portNotOpenError
  172.         
  173.         win32file.PurgeComm(self.hComPort, win32file.PURGE_TXCLEAR | win32file.PURGE_TXABORT)
  174.  
  175.     
  176.     def sendBreak(self):
  177.         if not (self.hComPort):
  178.             raise portNotOpenError
  179.         
  180.         import time
  181.         win32file.SetCommBreak(self.hComPort)
  182.         time.sleep(0.02)
  183.         win32file.ClearCommBreak(self.hComPort)
  184.  
  185.     
  186.     def setRTS(self, level = 1):
  187.         if not (self.hComPort):
  188.             raise portNotOpenError
  189.         
  190.         if level:
  191.             win32file.EscapeCommFunction(self.hComPort, win32file.SETRTS)
  192.         else:
  193.             win32file.EscapeCommFunction(self.hComPort, win32file.CLRRTS)
  194.  
  195.     
  196.     def setDTR(self, level = 1):
  197.         if not (self.hComPort):
  198.             raise portNotOpenError
  199.         
  200.         if level:
  201.             win32file.EscapeCommFunction(self.hComPort, win32file.SETDTR)
  202.         else:
  203.             win32file.EscapeCommFunction(self.hComPort, win32file.CLRDTR)
  204.  
  205.     
  206.     def getCTS(self):
  207.         if not (self.hComPort):
  208.             raise portNotOpenError
  209.         
  210.         return MS_CTS_ON & win32file.GetCommModemStatus(self.hComPort) != 0
  211.  
  212.     
  213.     def getDSR(self):
  214.         if not (self.hComPort):
  215.             raise portNotOpenError
  216.         
  217.         return MS_DSR_ON & win32file.GetCommModemStatus(self.hComPort) != 0
  218.  
  219.     
  220.     def getRI(self):
  221.         if not (self.hComPort):
  222.             raise portNotOpenError
  223.         
  224.         return MS_RING_ON & win32file.GetCommModemStatus(self.hComPort) != 0
  225.  
  226.     
  227.     def getCD(self):
  228.         if not (self.hComPort):
  229.             raise portNotOpenError
  230.         
  231.         return MS_RLSD_ON & win32file.GetCommModemStatus(self.hComPort) != 0
  232.  
  233.     
  234.     def setXON(self, level = True):
  235.         if not (self.hComPort):
  236.             raise portNotOpenError
  237.         
  238.         if level:
  239.             win32file.EscapeCommFunction(self.hComPort, win32file.SETXON)
  240.         else:
  241.             win32file.EscapeCommFunction(self.hComPort, win32file.SETXOFF)
  242.  
  243.  
  244. if __name__ == '__main__':
  245.     print __name__
  246.     s = Serial()
  247.     print s
  248.     s = Serial(0)
  249.     print s
  250.     s.baudrate = 19200
  251.     s.databits = 7
  252.     s.close()
  253.     s.port = 3
  254.     s.open()
  255.     print s
  256.  
  257.